const Chat = require('../models/chat.model');
const AIService = require('../utils/ai.service');

class ChatController {
    // 创建新会话
    static async createSession(req, res) {
        try {
            const { sessionName } = req.body;
            const userId = req.user.userId;

            // 添加输入验证
            if (!sessionName) {
                return res.status(400).json({ 
                    message: '会话名称不能为空',
                    code: 'MISSING_SESSION_NAME'
                });
            }

            // 添加调试日志
            console.log('创建会话请求:', {
                userId,
                sessionName,
                body: req.body,
                headers: req.headers
            });

            const sessionId = await Chat.createSession(userId, sessionName);
            
            res.status(201).json({
                message: '会话创建成功',
                sessionId,
                sessionName
            });
        } catch (error) {
            console.error('创建会话错误:', error);
            res.status(500).json({ 
                message: '服务器错误',
                error: error.message 
            });
        }
    }

    // 获取所有会话
    static async getSessions(req, res) {
        try {
            const userId = req.user.userId;
            const sessions = await Chat.getSessions(userId);
            
            res.json(sessions);
        } catch (error) {
            console.error('获取会话列表错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }

    // 发送消息并获取AI回复
    static async sendMessage(req, res) {
        try {
            const { sessionId, message } = req.body;
            const userId = req.user.userId;

            // 验证输入
            if (!sessionId || !message) {
                return res.status(400).json({
                    error: '缺少必要参数',
                    details: {
                        sessionId: !sessionId ? '会话ID不能为空' : null,
                        message: !message ? '消息内容不能为空' : null
                    }
                });
            }

            // 验证会话是否存在
            const session = await Chat.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({ error: '会话不存在' });
            }

            console.log('开始处理消息:', { sessionId, userId, message });

            // 获取历史消息
            const historyMessages = await Chat.getMessages(sessionId, userId);
            const formattedHistory = historyMessages.map(msg => ({
                role: msg.role,
                content: msg.content
            }));

            // 保存用户消息
            await Chat.saveMessage(sessionId, userId, 'user', message);

            // 设置响应头以支持流式输出
            res.setHeader('Content-Type', 'text/event-stream');
            res.setHeader('Cache-Control', 'no-cache');
            res.setHeader('Connection', 'keep-alive');

            let fullResponse = '';

            // 获取AI回复（使用流式输出）
            try {
                const aiResponse = await AIService.getAIResponse(
                    message,
                    formattedHistory,
                    (chunk) => {
                        const dataString = `data: ${JSON.stringify({ content: chunk })}\n\n`;
                        res.write(dataString);
                        fullResponse += chunk;
                    }
                );

                // 保存完整的AI回复到数据库
                await Chat.saveMessage(sessionId, userId, 'assistant', fullResponse);

                // 结束流式响应
                res.write('data: [DONE]\n\n');
                res.end();
            } catch (aiError) {
                console.error('AI服务错误:', aiError);
                res.write(`data: ${JSON.stringify({ 
                    error: '与AI服务通信时出错',
                    details: aiError.message 
                })}\n\n`);
                res.end();
            }
        } catch (error) {
            console.error('发送消息错误:', error);
            if (!res.headersSent) {
                res.write(`data: ${JSON.stringify({ 
                    error: '服务器错误',
                    details: error.message 
                })}\n\n`);
            }
            res.end();
        }
    }

    // 获取会话历史消息
    static async getMessages(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            const messages = await Chat.getMessages(sessionId, userId);
            
            res.json(messages);
        } catch (error) {
            console.error('获取消息历史错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }

    // 重命名会话
    static async renameSession(req, res) {
        try {
            const { sessionId } = req.params;
            const { newName } = req.body;
            const userId = req.user.userId;

            const success = await Chat.renameSession(sessionId, userId, newName);
            
            if (success) {
                res.json({ message: '重命名成功' });
            } else {
                res.status(404).json({ message: '会话不存在' });
            }
        } catch (error) {
            console.error('重命名会话错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }

    // 删除会话
    static async deleteSession(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            const success = await Chat.deleteSession(sessionId, userId);
            
            if (success) {
                res.json({ message: '删除成功' });
            } else {
                res.status(404).json({ message: '会话不存在' });
            }
        } catch (error) {
            console.error('删除会话错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }
}

module.exports = ChatController; 